// utils/api.js

// 请求封装
function request(url, method, data = {}) {
  return new Promise((resolve, reject) => {
    // 获取app实例，如果获取失败则使用默认值
    const app = getApp()
    const globalData = app ? app.globalData : { token: '' }
    
    // 管理员方法不需要Authorization头，使用session认证
    const adminMethods = [
      '/getOrders', '/getAllocations', '/getReports', 
      '/auditReport', '/getReportDetail', '/getProducts', 
      '/getProcesses', '/getUsers', '/createAllocation', 
      '/batchCreateAllocation', '/getOrderModels', 
      '/getOrderDetail', '/createOrder', '/updateOrder', 
      '/deleteOrder', '/adminLogin', '/checkToken',
      '/getActiveReports', '/getActiveReportDetail', '/auditActiveReport',
      '/getProductList', '/createProduct', '/updateProduct', '/deleteProduct',
      '/getProductModelList', '/createProductModel', '/updateProductModel', '/deleteProductModel',
      '/getProcessList', '/createProcess', '/updateProcess', '/deleteProcess',
      '/getProcessPriceList', '/createProcessPrice', '/updateProcessPrice', '/deleteProcessPrice', '/batchProcessPrice',
      '/getAdminPermissions', '/getOrderProgressList', '/getProcessProgressStats', '/getOrderProgressDetail', '/getProgressFilterOptions',
      '/getProductionPlans', '/createProductionPlan', '/updateProductionPlan', '/deleteProductionPlan', '/getProductionPlanDetail',
      '/getProductionPlanAllocations', '/allocateProductionPlan', '/batchAllocateProductionPlan', '/saveBatchAllocateProductionPlan',
      '/getProductionPlanProgress', '/startProductionPlan', '/pauseProductionPlan', '/resumeProductionPlan', '/completeProductionPlan',
      '/updateProductionPlanProgress', '/getProductionPlanStats', '/generateProductionPlanFromOrder', '/getOrderProducts'
    ];
    
    const isAdminMethod = adminMethods.some(method => url.includes(method));
    
    const headers = {
      'content-type': 'application/json'
    };
    
    // 所有方法都添加Authorization头（如果token存在）
    if (globalData.token) {
      headers['Authorization'] = 'Bearer ' + globalData.token;
    }
    
    wx.request({
      url: globalData.baseUrl + url,
      method: method,
      data: data,
      header: headers,
              success: (res) => {
          console.log('API响应:', res.data)
          if (res.statusCode === 200) {
            if (res.data.code == 1) {
              resolve(res.data)
            } else {
              // 检查权限错误
              if (res.data.msg && res.data.msg.includes('权限')) {
                wx.showModal({
                  title: '权限不足',
                  content: res.data.msg,
                  showCancel: false,
                  success: () => {
                    // 跳转到登录页面或首页
                    wx.reLaunch({
                      url: '/pages/login/login'
                    });
                  }
                });
                reject(res.data);
                return;
              }
              
              wx.showToast({
                title: res.data.msg || '请求失败',
                icon: 'none'
              })
              reject(res.data)
            }
          } else if (res.statusCode === 401) {
            // 401错误，跳转到登录页
            wx.showToast({
              title: '请先登录',
              icon: 'none'
            })
            wx.reLaunch({
              url: '/pages/login/login'
            })
            reject(res)
          } else if (res.statusCode === 403) {
            // 403权限错误
            wx.showModal({
              title: '权限不足',
              content: '您没有权限执行此操作',
              showCancel: false,
              success: () => {
                wx.reLaunch({
                  url: '/pages/login/login'
                });
              }
            });
            reject(res);
          } else {
            wx.showToast({
              title: '网络错误',
              icon: 'none'
            })
            reject(res)
          }
        },
      fail: (err) => {
        wx.showToast({
          title: '请求失败',
          icon: 'none'
        })
        reject(err)
      }
    })
  })
}

// API方法
const api = {
  // 获取订单型号
  getOrderModels(orderId) {
    return request('/getOrderModels', 'GET', { order_id: orderId })
  },

  // 获取订单列表
  getOrders(params = {}) {
    return request('/getOrders', 'GET', params)
  },

  // 获取订单详情
  getOrderDetail(orderId) {
    return request('/getOrderDetail', 'GET', { order_id: orderId })
  },

  // 创建订单
  createOrder(data) {
    return request('/createOrder', 'POST', data)
  },

  // 更新订单
  updateOrder(orderId, data) {
    return request('/updateOrder', 'POST', { order_id: orderId, ...data })
  },

  // 删除订单
  deleteOrder(orderId) {
    return request('/deleteOrder', 'POST', { order_id: orderId })
  },

  // 获取分工任务列表
  getAllocations(params) {
    return request('/getAllocations', 'GET', params)
  },

  // 获取我的分工任务
  getMyAllocations(params) {
    return request('/getMyAllocations', 'GET', params)
  },

  // 提交报工
  submitReport(data) {
    return request('/submitReport', 'POST', data)
  },

  // 上传报工图片
  uploadReportImage(reportId, filePath) {
    return new Promise((resolve, reject) => {
      const app = getApp()
      const globalData = app ? app.globalData : { baseUrl: 'https://crm.user.023ent.net/api', token: '' }
      
      wx.uploadFile({
        url: globalData.baseUrl + '/uploadReportImage',
        filePath: filePath,
        name: 'image',
        formData: {
          report_id: reportId
        },
        header: {
          'Authorization': 'Bearer ' + globalData.token
        },
        success: (res) => {
          const data = JSON.parse(res.data)
          if (data.code === 1) {
            resolve(data)
          } else {
            wx.showToast({
              title: data.msg || '上传失败',
              icon: 'none'
            })
            reject(data)
          }
        },
        fail: (err) => {
          wx.showToast({
            title: '上传失败',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  },

  // 上传审核图片
  uploadAuditImage(reportId, filePath, itemNo) {
    return new Promise((resolve, reject) => {
      const app = getApp()
      const globalData = app ? app.globalData : { baseUrl: 'https://crm.user.023ent.net/api', token: '' }
      
      // 添加认证头 - 优先使用管理员token
      const headers = {}
      const adminToken = wx.getStorageSync('adminToken') || globalData.token
      if (adminToken) {
        headers['Authorization'] = 'Bearer ' + adminToken
      }
      
      wx.uploadFile({
        url: globalData.baseUrl + '/uploadAuditImage',
        filePath: filePath,
        name: 'audit_images',
        header: headers,
        formData: {
          report_id: reportId,
          item_no: itemNo
        },
        success: (res) => {
          const data = JSON.parse(res.data)
          if (data.code === 1) {
            resolve(data)
          } else {
            wx.showToast({
              title: data.msg || '上传失败',
              icon: 'none'
            })
            reject(data)
          }
        },
        fail: (err) => {
          wx.showToast({
            title: '上传失败',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  },

  // 上传审核视频
  uploadAuditVideo(reportId, filePath, itemNo) {
    return new Promise((resolve, reject) => {
      const app = getApp()
      const globalData = app ? app.globalData : { baseUrl: 'https://crm.user.023ent.net/api', token: '' }
      
      // 添加认证头 - 优先使用管理员token
      const headers = {}
      const adminToken = wx.getStorageSync('adminToken') || globalData.token
      if (adminToken) {
        headers['Authorization'] = 'Bearer ' + adminToken
      }
      
      wx.uploadFile({
        url: globalData.baseUrl + '/uploadAuditVideo',
        filePath: filePath,
        name: 'audit_videos',
        header: headers,
        formData: {
          report_id: reportId,
          item_no: itemNo
        },
        success: (res) => {
          console.log('视频上传响应:', res)
          try {
            const data = JSON.parse(res.data)
            if (data.code === 1) {
              resolve(data)
            } else {
              wx.showToast({
                title: data.msg || '上传失败',
                icon: 'none'
              })
              reject(data)
            }
          } catch (e) {
            console.error('解析响应失败:', e, '响应数据:', res.data)
            wx.showToast({
              title: '服务器响应格式错误',
              icon: 'none'
            })
            reject(e)
          }
        },
        fail: (err) => {
          console.error('视频上传失败:', err)
          wx.showToast({
            title: '上传失败',
            icon: 'none'
          })
          reject(err)
        }
      })
    })
  },

  // 获取报工列表
  getReports(params) {
    return request('/getReports', 'GET', params)
  },

  // 获取主动报工列表
  getActiveReports(params) {
    return request('/getActiveReports', 'GET', params)
  },

  // 获取报工详情
  getReportDetail(reportId) {
    return request('/getReportDetail', 'GET', { report_id: reportId })
  },

  // 获取主动报工详情
  getActiveReportDetail(reportId) {
    return request('/getActiveReportDetail', 'GET', { report_id: reportId })
  },

  // 审核报工
  auditReport(data) {
    return request('/auditReport', 'POST', data)
  },

  // 审核主动报工
  auditActiveReport(data) {
    return request('/auditActiveReport', 'POST', data)
  },

  // 审核普通报工
  auditReport(data) {
    return request('/auditReport', 'POST', data)
  },

  // 获取产品列表
  getProducts() {
    return request('/getProducts', 'GET')
  },

  // 获取产品型号列表
  getModels(params) {
    return request('/getModels', 'GET', params)
  },

  // 获取工序列表
  getProcesses() {
    return request('/getProcesses', 'GET')
  },

  // 获取员工列表
  getUsers() {
    return request('/getUsers', 'GET')
  },

  // 管理员登录
  adminLogin(data) {
    return request('/adminLogin', 'POST', data)
  },

  // 验证token
  checkToken() {
    return request('/checkToken', 'GET')
  },

  // 创建分工任务
  createAllocation(data) {
    return request('/createAllocation', 'POST', data)
  },

  // 批量创建分工任务
  batchCreateAllocation(data) {
    return request('/batchCreateAllocation', 'POST', data)
  },

  // ==================== 产品管理 ====================
  
  // 获取产品列表
  getProductList(params) {
    return request('/getProductList', 'GET', params)
  },

  // 创建产品
  createProduct(data) {
    return request('/createProduct', 'POST', data)
  },

  // 更新产品
  updateProduct(data) {
    return request('/updateProduct', 'POST', data)
  },

  // 删除产品
  deleteProduct(id) {
    return request('/deleteProduct', 'POST', { id: id })
  },

  // ==================== 产品型号管理 ====================
  
  // 获取产品型号列表
  getProductModelList(params) {
    return request('/getProductModelList', 'GET', params)
  },

  // 创建产品型号
  createProductModel(data) {
    return request('/createProductModel', 'POST', data)
  },

  // 更新产品型号
  updateProductModel(data) {
    return request('/updateProductModel', 'POST', data)
  },

  // 删除产品型号
  deleteProductModel(id) {
    return request('/deleteProductModel', 'POST', { id: id })
  },

  // ==================== 工序管理 ====================
  
  // 获取工序列表
  getProcessList(params) {
    return request('/getProcessList', 'GET', params)
  },

  // 创建工序
  createProcess(data) {
    return request('/createProcess', 'POST', data)
  },

  // 更新工序
  updateProcess(data) {
    return request('/updateProcess', 'POST', data)
  },

  // 删除工序
  deleteProcess(id) {
    return request('/deleteProcess', 'POST', { id: id })
  },

  // ==================== 工序工价管理 ====================
  
  // 获取工序工价列表
  getProcessPriceList(params) {
    return request('/getProcessPriceList', 'GET', params)
  },

  // 创建工序工价
  createProcessPrice(data) {
    return request('/createProcessPrice', 'POST', data)
  },

  // 更新工序工价
  updateProcessPrice(data) {
    return request('/updateProcessPrice', 'POST', data)
  },

  // 删除工序工价
  deleteProcessPrice(id) {
    return request('/deleteProcessPrice', 'POST', { id: id })
  },

  // 批量设置工序工价
  batchProcessPrice(data) {
    return request('/batchProcessPrice', 'POST', data)
  },

  // ==================== 权限管理 ====================
  
  // 获取管理员权限信息
  getAdminPermissions() {
    return request('/getAdminPermissions', 'GET')
  },

  // 检查是否有权限执行某个操作
  checkPermission(module, action) {
    return new Promise((resolve, reject) => {
      this.getAdminPermissions().then(res => {
        if (res.code === 1) {
          const permissions = res.data.permissions;
          const isSuperAdmin = res.data.is_super_admin;
          
          // 超级管理员拥有所有权限
          if (isSuperAdmin) {
            resolve(true);
            return;
          }
          
          // 检查具体权限
          const modulePermissions = permissions[module] || [];
          const hasPermission = modulePermissions.includes(action);
          
          if (hasPermission) {
            resolve(true);
          } else {
            reject(new Error(`没有权限执行操作: ${module}.${action}`));
          }
        } else {
          reject(new Error('获取权限信息失败'));
        }
      }).catch(err => {
        reject(err);
      });
    });
  },

  // 权限检查装饰器
  withPermission(module, action, apiCall) {
    return this.checkPermission(module, action).then(() => {
      return apiCall();
    });
  },

  // 管理员登录
  adminLogin(data) {
    return request('/adminLogin', 'POST', data)
  },

  // 检查token
  checkToken() {
    return request('/checkToken', 'GET')
  },

  // ==================== 管理员管理 ====================
  
  // 获取管理员列表
  getAdminList(params = {}) {
    return request('/getAdminList', 'GET', params)
  },

  // 创建管理员
  createAdmin(data) {
    return request('/createAdmin', 'POST', data)
  },

  // 更新管理员
  updateAdmin(data) {
    return request('/updateAdmin', 'POST', data)
  },

  // 删除管理员
  deleteAdmin(id) {
    return request('/deleteAdmin', 'POST', { id: id })
  },

  // 获取管理员详情
  getAdminDetail(id) {
    return request('/getAdminDetail', 'GET', { id: id })
  },

  // ==================== 订单进度管理 ====================
  
  // 获取订单进度列表
  getOrderProgressList(params = {}) {
    return request('/getOrderProgressList', 'GET', params)
  },

  // 获取工序进度统计
  getProcessProgressStats(params = {}) {
    return request('/getProcessProgressStats', 'GET', params)
  },

  // 获取订单进度详情
  getOrderProgressDetail(orderId) {
    return request('/getOrderProgressDetail', 'GET', { order_id: orderId })
  },

  // 获取筛选选项
  getProgressFilterOptions() {
    return request('/getProgressFilterOptions', 'GET', {})
  },

  // ==================== 主动报工审核 ====================
  
  // 上传主动报工审核图片
  uploadActiveAuditImage(reportId, filePath, itemNo) {
    return new Promise((resolve, reject) => {
      wx.uploadFile({
        url: getApp().globalData.baseUrl + '/uploadAuditImage',
        filePath: filePath,
        name: 'audit_images',
        formData: {
          report_id: reportId,
          item_no: itemNo,
          report_type: 'active' // 指定为主动报工
        },
        header: {
          'Authorization': 'Bearer ' + getApp().globalData.token
        },
        success: (res) => {
          try {
            const data = JSON.parse(res.data)
            if (data.code === 1) {
              resolve(data)
            } else {
              reject(data)
            }
          } catch (e) {
            reject(new Error('上传失败'))
          }
        },
        fail: (err) => {
          reject(err)
        }
      })
    })
  },

  // 上传主动报工审核视频
  uploadActiveAuditVideo(reportId, filePath, itemNo) {
    return new Promise((resolve, reject) => {
      wx.uploadFile({
        url: getApp().globalData.baseUrl + '/uploadAuditVideo',
        filePath: filePath,
        name: 'audit_videos',
        formData: {
          report_id: reportId,
          item_no: itemNo,
          report_type: 'active' // 指定为主动报工
        },
        header: {
          'Authorization': 'Bearer ' + getApp().globalData.token
        },
        success: (res) => {
          try {
            const data = JSON.parse(res.data)
            if (data.code === 1) {
              resolve(data)
            } else {
              reject(data)
            }
          } catch (e) {
            reject(new Error('上传失败'))
          }
        },
        fail: (err) => {
          reject(err)
        }
      })
    })
  },

  // ==================== 工序-员工关联管理 ====================
  
  // 获取工序列表
  getProcessList() {
    return request('/getProcessList', 'GET', {})
  },

  // 获取工序关联的员工
  getProcessUsers(processId) {
    return request('/getProcessUsers', 'GET', { process_id: processId })
  },

  // 获取可添加的员工列表
  getAvailableUsers(processId) {
    return request('/getAvailableUsers', 'GET', { process_id: processId })
  },

  // 添加工序-员工关联
  addProcessUsers(processId, userIds) {
    return request('/addProcessUsers', 'POST', { 
      process_id: processId, 
      user_ids: userIds 
    })
  },

  // 移除工序-员工关联
  removeProcessUser(processId, userId) {
    return request('/removeProcessUser', 'POST', { 
      process_id: processId, 
      user_id: userId 
    })
  },

  // ==================== 用户管理 ====================
  
  // 获取用户列表
  getUserList(params = {}) {
    return request('/getUserList', 'GET', params)
  },

  // 更新用户信息
  updateUser(userData) {
    return request('/updateUser', 'POST', userData)
  },

  // 删除用户
  deleteUser(userId) {
    return request('/deleteUser', 'POST', { id: userId })
  },

  // 修改用户密码
  changeUserPassword(passwordData) {
    return request('/changeUserPassword', 'POST', passwordData)
  },

  // ==================== 生产计划管理 ====================
  
  // 获取生产计划列表
  getProductionPlans(params = {}) {
    return request('/getProductionPlans', 'GET', params)
  },

  // 创建生产计划
  createProductionPlan(data) {
    return request('/createProductionPlan', 'POST', data)
  },

  // 更新生产计划
  updateProductionPlan(data) {
    return request('/updateProductionPlan', 'POST', data)
  },

  // 删除生产计划
  deleteProductionPlan(id) {
    return request('/deleteProductionPlan', 'POST', { id: id })
  },

  // 获取生产计划详情
  getProductionPlanDetail(id) {
    return request('/getProductionPlanDetail', 'GET', { id: id })
  },

  // 获取生产计划的分工分配
  getProductionPlanAllocations(planId) {
    return request('/getProductionPlanAllocations', 'GET', { plan_id: planId })
  },

  // 工序分配管理
  allocateProductionPlan(planId) {
    return request('/allocateProductionPlan', 'GET', { plan_id: planId })
  },

  // 批量分配工序
  batchAllocateProductionPlan(planId) {
    return request('/batchAllocateProductionPlan', 'GET', { plan_id: planId })
  },

  // 保存批量分配
  saveBatchAllocateProductionPlan(data) {
    return request('/saveBatchAllocateProductionPlan', 'POST', data)
  },

  // 开始生产计划
  startProductionPlan(id) {
    return request('/startProductionPlan', 'POST', { id: id })
  },

  // 暂停生产计划
  pauseProductionPlan(id) {
    return request('/pauseProductionPlan', 'POST', { id: id })
  },

  // 恢复生产计划
  resumeProductionPlan(id) {
    return request('/resumeProductionPlan', 'POST', { id: id })
  },

  // 完成生产计划
  completeProductionPlan(id) {
    return request('/completeProductionPlan', 'POST', { id: id })
  },

  // 更新生产计划进度
  updateProductionPlanProgress(id) {
    return request('/updateProductionPlanProgress', 'POST', { id: id })
  },

  // 获取生产计划统计信息
  getProductionPlanStats(id) {
    return request('/getProductionPlanStats', 'GET', { id: id })
  },

  // 获取生产进度统计
  getProductionPlanProgress(params = {}) {
    return request('/getProductionPlanProgress', 'GET', params)
  },

  // 基于订单生成生产计划
  generateProductionPlanFromOrder(orderId) {
    return request('/generateProductionPlanFromOrder', 'POST', { order_id: orderId })
  },

  // 根据订单获取产品和型号信息
  getOrderProducts(orderId) {
    return request('/getOrderProducts', 'GET', { order_id: orderId })
  }
}

module.exports = api 